package com.cyan.teamquestionnaire.controller;

import com.cyan.teamquestionnaire.beans.HttpResponseEntity;
import com.cyan.teamquestionnaire.beans.PageInfo;
import com.cyan.teamquestionnaire.entity.AnswerSheet;
import com.cyan.teamquestionnaire.entity.Questionnaire;
import com.cyan.teamquestionnaire.entity.QuestionnaireFee;
import com.cyan.teamquestionnaire.entity.User;
import com.cyan.teamquestionnaire.service.QuestionnaireService;
import com.cyan.teamquestionnaire.utils.Constants;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;

@RestController
public class QuestionnaireController {
    @Resource
    private QuestionnaireService questionnaireService;

    // 返回信息
    @Resource
    private HttpResponseEntity httpResponseEntity;

    // 必读，查询这些问卷，此时是可以把那些模板查询出来的，因为有可能这些模板（name==null），还没讨论
    // 模板是如何创建出来的，归属问题如何，所以这里的查询就没有排除模板

    // （分页）查询用户创建的所有问卷，后缀Y表示分页(不是模糊)
    @RequestMapping(value = "/allQuestionnairesY", method = RequestMethod.POST)
    public HttpResponseEntity allQuestionnaire(@RequestBody PageInfo<Questionnaire> pageInfo) {
        pageInfo = questionnaireService.selectByCreatorName(pageInfo);
        httpResponseEntity.setData(pageInfo);
        httpResponseEntity.setCode(Constants.SUCCESS_CODE);
        httpResponseEntity.setMessage(Constants.STATUS_MESSAGE);
        return httpResponseEntity;
    }

    // （分页）请求问卷，请求的操作通过title的查询
    @RequestMapping(value = "/queryQuestionnairesByTitleY", method = RequestMethod.POST)
    public HttpResponseEntity queryQuestionnairesByTitle(@RequestBody PageInfo<Questionnaire> pageInfo) {
        // 查询出来的数据
        pageInfo = questionnaireService.queryQuestionnaireByTitle(pageInfo);
        httpResponseEntity.setMessage(Constants.STATUS_MESSAGE);
        httpResponseEntity.setCode(Constants.SUCCESS_CODE);
        httpResponseEntity.setData(pageInfo);
        return httpResponseEntity;
    }

    // （分页）请求问卷，请求的操作通过qid的查询
    @RequestMapping(value = "/queryQuestionnairesByQidY", method = RequestMethod.POST)
    public HttpResponseEntity queryQuestionnairesByQid(@RequestBody PageInfo<Questionnaire> pageInfo) {
        // 查询出来的数据
        pageInfo = questionnaireService.queryQuestionnaireByQid(pageInfo);
        httpResponseEntity.setMessage(Constants.STATUS_MESSAGE);
        httpResponseEntity.setCode(Constants.SUCCESS_CODE);
        httpResponseEntity.setData(pageInfo);
        return httpResponseEntity;
    }

    // (不分页) 通过姓名请求问卷,后缀有N表示不分页（不是模糊查询）
    @RequestMapping(value = "/queryQuestionnaireByNameN", method = RequestMethod.POST)
    public HttpResponseEntity queryQuestionByName(String name) {
        List<Questionnaire> list = questionnaireService.selectByCreatorName(name);
        httpResponseEntity.setCode(Constants.SUCCESS_CODE);
        httpResponseEntity.setData(list);
        httpResponseEntity.setMessage(Constants.STATUS_MESSAGE);
        return httpResponseEntity;
    }

    // （不分页）通过qid请求问卷
    @RequestMapping(value = "/queryQuestionnaireByQidN", method = RequestMethod.POST)
    public HttpResponseEntity queryQuestionnaireByQidN(String qId) {
        List<Questionnaire> list = questionnaireService.queryQuestionnaireByQid(qId);

        httpResponseEntity.setCode(Constants.SUCCESS_CODE);
        httpResponseEntity.setData(list);
        httpResponseEntity.setMessage(Constants.STATUS_MESSAGE);

        return httpResponseEntity;
    }

    // （不分页）通过title请求问卷
    @RequestMapping(value = "/queryQuestionnaireByTitleN", method = RequestMethod.POST)
    public HttpResponseEntity queryQuestionnaireByTitleN(@RequestBody Map<String, Object> map) {
        String title = (String) map.get("title");
        String name = (String) map.get("name");
        List<Questionnaire> list = questionnaireService.queryQuestionnaireByTitle(title, name);
        httpResponseEntity.setCode(Constants.SUCCESS_CODE);
        httpResponseEntity.setData(list);
        httpResponseEntity.setMessage(Constants.STATUS_MESSAGE);
        return httpResponseEntity;
    }

    /**
     * 查询模板（name==null），不分页，模糊查询
     * 传入参数模板的title
     */
    @RequestMapping(value = "/queryTemplateByTitleN", method = RequestMethod.POST)
    public HttpResponseEntity queryTemplateByTitleN(String title) {
        List<Questionnaire> list = questionnaireService.queryTemplate(title);
        httpResponseEntity.setCode(Constants.SUCCESS_CODE);
        httpResponseEntity.setData(list);
        httpResponseEntity.setMessage(Constants.STATUS_MESSAGE);
        return httpResponseEntity;
    }

    /**
     * 查询模板（name==null），分页，模糊查询
     * 传入参数pageInfo
     */
    @RequestMapping(value = "/queryTemplateByTitleY", method = RequestMethod.POST)
    public HttpResponseEntity queryTemplateByTitleY(@RequestBody PageInfo<Questionnaire> pageInfo) {

        pageInfo = questionnaireService.queryTemplateY(pageInfo);
        httpResponseEntity.setCode(Constants.SUCCESS_CODE);
        httpResponseEntity.setData(pageInfo);
        httpResponseEntity.setMessage(Constants.STATUS_MESSAGE);
        return httpResponseEntity;
    }

    /**
     * 新建问卷，传入属性：name,gid,title,content (qid后台自动生成)
     * 前端先选中群组才能创建问卷，所以gid一定是合法的。同理，name也合法
     */
    @RequestMapping(value = "/createQuestionnaire", method = RequestMethod.POST)
    public HttpResponseEntity createQuestionnaire(@RequestBody Questionnaire questionnaire) {
        System.out.println(questionnaire);
        // 新建问卷时，时间相关属性默认为null，status默认为1
        questionnaireService.insertQuestionnaire(questionnaire);
        httpResponseEntity.setCode(Constants.SUCCESS_CODE);
        httpResponseEntity.setData(questionnaire);
        httpResponseEntity.setMessage(Constants.CREAT_QUES);
        return httpResponseEntity;
    }

    /**
     * 生成问卷链接，初步想法是直接传问卷内容，然后将问卷内容
     * 显示到前端界面，所以直接点获取问卷就行，这个能满足很多功能点
     *
     * @return 问卷内容
     */
    @RequestMapping("/questionnaireLink")
    public HttpResponseEntity getQuestionnaire(String qId) {
        return httpResponseEntity;
    }

    // 真正的删除操作，直接从数据库删除，而不是回收站
    @RequestMapping("/deleteQuestionnaireByQid")
    public HttpResponseEntity deleteQuestionnaireByQid(String qId) {
        int r = questionnaireService.deleteQuestionnaire(qId);
        if (r == 0) {// 返回删除行数，我这也没测试不了是不是返回的操作行数，先试试，可能有问题
            httpResponseEntity.setCode(Constants.EXIST_CODE);
            httpResponseEntity.setMessage(Constants.DELETE_Q_FALSE);
        } else {
            httpResponseEntity.setCode(Constants.SUCCESS_CODE);
            httpResponseEntity.setMessage(Constants.DELETE_Q_TRUE);
        }
        return httpResponseEntity;
    }

    /**
     * 将放在回收站中的问卷进行恢复
     * 传入qId,修改status从3变成0或者2（区分是release_time和gid是否为null）。
     */

    @RequestMapping(value = "/recoveryDeletedQuestionnaire", method = RequestMethod.POST)
    public HttpResponseEntity recoveryDeletedQuestionnaire(String qId) {
        // 只需要修改status即可
        //将问卷的状态修改
        questionnaireService.recoveryDeletedQuestionnaire(qId);
        httpResponseEntity.setCode(Constants.SUCCESS_CODE);
        httpResponseEntity.setMessage(Constants.Recovery_Success);
        return httpResponseEntity;
    }


    /**
     * 将问卷放到回收站，其实就是修改一下状态
     * 只需要传qId即可，问卷必须先关闭才能删除、
     */
    @RequestMapping(value = "/putQuestionnaireToBin", method = RequestMethod.POST)
    public HttpResponseEntity putQuestionnaireToBin(String qId) {
        // 假设前端传过来的数据一定是对的
        Questionnaire q = questionnaireService.queryQuestionnaireByQid(qId).get(0);
        if (q.getStatus().equals("1")) { // 问卷发布中
            httpResponseEntity.setCode(Constants.EXIST_CODE);
            httpResponseEntity.setMessage(Constants.DELETE_Q_PUB);
        } else {
            questionnaireService.putQuestionnaireToBin(q);
            httpResponseEntity.setCode(Constants.SUCCESS_CODE);
            httpResponseEntity.setMessage(Constants.DELETE_Q_TRUE);
        }
        return httpResponseEntity;
    }

    /**
     * 对name删除的（回收站的）问卷进行查询，传入name以及title
     * 对title进行模糊查询,一定成功
     */
    @RequestMapping(value = "/getQuestionnaireFromBin", method = RequestMethod.POST)
    public HttpResponseEntity getQuestionnaireFromBin(@RequestBody PageInfo<Questionnaire> pageInfo) {

        pageInfo = questionnaireService.getQuestionnaireFromBin(pageInfo);
        httpResponseEntity.setData(pageInfo);
        httpResponseEntity.setCode(Constants.SUCCESS_CODE);
        httpResponseEntity.setMessage(Constants.STATUS_MESSAGE);
        return httpResponseEntity;
    }

    /**
     * 对name删除的（回收站的）问卷进行查询，传入name
     * 不分页，不模糊查询，直接返回List<Questionnaire></>
     */
    @RequestMapping(value = "/getQuestionnaireFromBinNY", method = RequestMethod.POST)
    public HttpResponseEntity getQuestionnaireFromBinNY(String name) {

        httpResponseEntity.setData(questionnaireService.getQuestionnaireFromBinNY(name));
        httpResponseEntity.setCode(Constants.SUCCESS_CODE);
        httpResponseEntity.setMessage(Constants.STATUS_MESSAGE);
        return httpResponseEntity;
    }


    /**
     *对问卷内容进行修改，
     * 只能修改status=0的问卷，其他状态的不能修改，模板也不行
     * qid、title、content
     */
    @RequestMapping(value = "/updateQuestionnaireContent", method = RequestMethod.POST)
    public HttpResponseEntity updateQuestionnaireContent(@RequestBody Questionnaire  questionnaire) {

      Questionnaire questionnaire1 = questionnaireService.queryQuestionnaireByQidEq(questionnaire.getQId());

        httpResponseEntity.setData(null);
        httpResponseEntity.setCode(Constants.EXIST_CODE);
      if (questionnaire1 == null){//问卷不存在
          httpResponseEntity.setMessage(Constants.NotFind_Q);
      }
      else if (questionnaire1.getName()==null){//问卷为模板
          httpResponseEntity.setMessage(Constants.Update_Q_Template);
      }
      else if (questionnaire1.getStatus().equals("1")){//问卷为开启状态
          httpResponseEntity.setMessage(Constants.Update_Q_status1);
      }
      else if (questionnaire1.getStatus().equals("2")){//问卷为暂停状态
          httpResponseEntity.setMessage(Constants.Update_Q_status2);
      }
      else if (questionnaire1.getStatus().equals("3")){//问卷为关闭状态---没有用
          httpResponseEntity.setMessage(Constants.Update_Q_status3);
      }
      else {//修改内容
          httpResponseEntity.setData(questionnaireService.updateQuestionnaireContent(questionnaire));
          httpResponseEntity.setCode(Constants.SUCCESS_CODE);
          httpResponseEntity.setMessage(Constants.MODIFY_SUCCESS);
      }
        return httpResponseEntity;
    }



    // 再次开启问卷，修改status状态
    @RequestMapping(value = "/issueQuestionnaire", method = RequestMethod.POST)
    public HttpResponseEntity issueQuestionnaire(@RequestBody Map<String, Object> map) {
        // 只需要修改status即可
        String qId = (String) map.get("qId");

        questionnaireService.updateStatus(qId, "1");
        httpResponseEntity.setCode(Constants.SUCCESS_CODE);
        httpResponseEntity.setMessage(Constants.ISSUE_SUCCESS);
        return httpResponseEntity;
    }


    // 发布问卷(第一次发布，需要指定群组)，自动设置当前时间和status状态
    @RequestMapping(value = "/issueQuestionnaireFirst", method = RequestMethod.POST)
    public HttpResponseEntity issueQuestionnaireFirst(@RequestBody Map<String, Object> map) {
        // service层暂时不通知群组的用户啥的
        String qId = (String) map.get("qId");
        String gId = (String) map.get("gId");
        String name = (String) map.get("name");
        boolean flag = questionnaireService.userHasSpace(name);
        if (flag) {
            questionnaireService.issue(qId, gId);
            httpResponseEntity.setCode(Constants.SUCCESS_CODE);
            httpResponseEntity.setMessage(Constants.ISSUE_SUCCESS);
        } else {
            httpResponseEntity.setCode(Constants.EXIST_CODE);
            httpResponseEntity.setMessage(Constants.ISSUE_FALSE);
        }

        return httpResponseEntity;
    }

    // 关闭问卷，设置状态为status=2
    @RequestMapping(value = "/closeQuestionnaire", method = RequestMethod.POST)
    public HttpResponseEntity closeQuestionnaire(String qId) {
        questionnaireService.updateStatus(qId, "2");
        httpResponseEntity.setCode(Constants.SUCCESS_CODE);
        httpResponseEntity.setMessage(Constants.CLOSE_SUCCESS);
        return httpResponseEntity;
    }

    /**
     * 单卷查看答卷情况，需要显示详细，其实就是返回答卷对象
     *
     * @param answerSheet 通过名字查看
     * @return 单卷情况 返回答案
     */
    @RequestMapping(value = "/singleViewAns", method = RequestMethod.POST)
    public HttpResponseEntity singleViewAns(@RequestBody AnswerSheet answerSheet) {
        answerSheet = questionnaireService.selectAnsweredSheet(answerSheet);
        httpResponseEntity.setData(answerSheet);
        httpResponseEntity.setCode(Constants.SUCCESS_CODE);
        return httpResponseEntity;
    }


    /**
     * 计费管理：歧义在于查询租户时，是显示所有计费还是单个问卷的计费
     * @param user 租户
     * @return 对租户的计费结果
     */
    @RequestMapping(value = "/fee", method = RequestMethod.POST)
    public HttpResponseEntity tenantFee(@RequestBody User user) {
        List<QuestionnaireFee> list = questionnaireService.getFeeOfTenant(user);
        int cnt = questionnaireService.groupCnt(user); // 租户管理的群组个数
        // 剩下的就是计费规则，先留着讨论一下吧，看怎么展示

        return httpResponseEntity;
    }

    // 租户下所有的问卷数
    @RequestMapping(value = "/cntQInTenant", method = RequestMethod.POST)
    public HttpResponseEntity cntQInTenant(String name) {
        httpResponseEntity.setData(questionnaireService.countQuestionnaire(name));
        httpResponseEntity.setCode(Constants.SUCCESS_CODE);
        httpResponseEntity.setMessage(Constants.STATUS_MESSAGE);
        return httpResponseEntity;
    }


    /**
     * 传入租户名tenant_name，——————分页
     * 联合tenant_user表和questionnaire表，返回该租户下的所有用户的status=1和status=2的问卷list，分页模糊。
     */
    @RequestMapping(value = "/questionnaireInTenantY", method = RequestMethod.POST)
    public HttpResponseEntity questionnaireInTenantY(@RequestBody PageInfo<Questionnaire> pageInfo) {

        pageInfo = questionnaireService.questionnaireInTenant(pageInfo);
        httpResponseEntity.setCode(Constants.SUCCESS_CODE);
        httpResponseEntity.setData(pageInfo);
        httpResponseEntity.setMessage(Constants.STATUS_MESSAGE);
        return httpResponseEntity;

    }

}
